Odblokowywanie współbieżności w Pythonie: ThreadPoolExecutor vs. ProcessPoolExecutor

Python, będąc wszechstronnym i szeroko stosowanym językiem programowania, ma pewne ograniczenia w zakresie prawdziwej równoległości z powodu Global Interpreter Lock (GIL). Moduł concurrent.futures zapewnia interfejs wysokiego poziomu do asynchronicznego wykonywania funkcji wywoływalnych, oferując sposób na obejście niektórych z tych ograniczeń i poprawę wydajności dla określonych typów zadań. Moduł ten zawiera dwie kluczowe klasy: ThreadPoolExecutor i ProcessPoolExecutor. Ten obszerny przewodnik zbada obie te klasy, podkreślając ich różnice, mocne i słabe strony, a także dostarczając praktycznych przykładów, które pomogą Ci wybrać odpowiedni executor dla Twoich potrzeb.

Zrozumienie współbieżności i równoległości

Zanim zagłębimy się w szczegóły każdego z executorów, kluczowe jest zrozumienie koncepcji współbieżności i równoległości. Terminy te są często używane zamiennie, ale mają odrębne znaczenia:

• Współbieżność: Dotyczy zarządzania wieloma zadaniami jednocześnie. Chodzi o strukturyzowanie kodu w taki sposób, aby obsługiwał wiele rzeczy pozornie jednocześnie, nawet jeśli są one faktycznie przeplatane na jednym rdzeniu procesora. Pomyśl o tym jak o kucharzu zarządzającym kilkoma garnkami na jednym palniku – nie wszystkie gotują się w *dokładnie* tym samym momencie, ale kucharz zarządza wszystkimi.
• Równoległość: Polega na faktycznym wykonywaniu wielu zadań *w tym samym czasie*, zazwyczaj poprzez wykorzystanie wielu rdzeni procesora. To jak posiadanie wielu kucharzy, z których każdy pracuje jednocześnie nad inną częścią posiłku.

GIL Pythona w dużej mierze uniemożliwia prawdziwą równoległość dla zadań CPU-bound przy użyciu wątków. Dzieje się tak, ponieważ GIL pozwala tylko jednemu wątkowi na przejęcie kontroli nad interpreterem Pythona w danym momencie. Jednak w przypadku zadań I/O-bound, gdzie program spędza większość czasu na oczekiwaniu na operacje zewnętrzne, takie jak żądania sieciowe lub odczyty z dysku, wątki nadal mogą zapewnić znaczną poprawę wydajności, pozwalając innym wątkom na uruchomienie, gdy jeden czeka.

Wprowadzenie do modułu `concurrent.futures`

Moduł concurrent.futures upraszcza proces asynchronicznego wykonywania zadań. Zapewnia interfejs wysokiego poziomu do pracy z wątkami i procesami, abstrahując od większości złożoności związanej z ich bezpośrednim zarządzaniem. Podstawową koncepcją jest „executor”, który zarządza wykonywaniem przesłanych zadań. Dwa główne executory to:

• ThreadPoolExecutor: Wykorzystuje pulę wątków do wykonywania zadań. Nadaje się do zadań I/O-bound.
• ProcessPoolExecutor: Wykorzystuje pulę procesów do wykonywania zadań. Nadaje się do zadań CPU-bound.

ThreadPoolExecutor: Wykorzystanie wątków do zadań I/O-bound

ThreadPoolExecutor tworzy pulę wątków roboczych do wykonywania zadań. Ze względu na GIL, wątki nie są idealne do operacji intensywnie wykorzystujących procesor, które korzystają z prawdziwej równoległości. Jednakże, doskonale sprawdzają się w scenariuszach I/O-bound. Przyjrzyjmy się, jak go używać:

Podstawowe użycie

Oto prosty przykład użycia ThreadPoolExecutor do jednoczesnego pobierania wielu stron internetowych:

import concurrent.futures
import requests
import time

urls = [
    "https://www.example.com",
    "https://www.google.com",
    "https://www.wikipedia.org",
    "https://www.python.org"
]


def download_page(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status() # Podnieś HTTPError dla błędnych odpowiedzi (4xx lub 5xx)
        print(f"Pobrane {url}: {len(response.content)} bajtów")
        return len(response.content)
    except requests.exceptions.RequestException as e:
        print(f"Błąd pobierania {url}: {e}")
        return 0


start_time = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    # Prześlij każdy URL do executor
    futures = [executor.submit(download_page, url) for url in urls]

    # Poczekaj na zakończenie wszystkich zadań
    total_bytes = sum(future.result() for future in concurrent.futures.as_completed(futures))

print(f"Całkowita liczba pobranych bajtów: {total_bytes}")
print(f"Czas wykonania: {time.time() - start_time:.2f} sekund")

Wyjaśnienie:

1. Importujemy niezbędne moduły: concurrent.futures, requests i time.
2. Definiujemy listę adresów URL do pobrania.
3. Funkcja download_page pobiera zawartość danego adresu URL. Obsługa błędów jest uwzględniona przy użyciu `try...except` i `response.raise_for_status()` do przechwytywania potencjalnych problemów z siecią.
4. Tworzymy ThreadPoolExecutor z maksymalnie 4 wątkami roboczymi. Argument max_workers kontroluje maksymalną liczbę wątków, które mogą być używane jednocześnie. Ustawienie go zbyt wysoko może nie zawsze poprawić wydajność, szczególnie w przypadku zadań I/O-bound, gdzie wąskim gardłem jest często przepustowość sieci.
5. Używamy list comprehension do przesłania każdego adresu URL do executor za pomocą executor.submit(download_page, url). Zwraca to obiekt Future dla każdego zadania.
6. Funkcja concurrent.futures.as_completed(futures) zwraca iterator, który generuje futures w miarę ich ukończenia. Pozwala to uniknąć oczekiwania na zakończenie wszystkich zadań przed przetworzeniem wyników.
7. Iterujemy przez ukończone futures i pobieramy wynik każdego zadania za pomocą future.result(), sumując całkowitą liczbę pobranych bajtów. Obsługa błędów w `download_page` zapewnia, że poszczególne awarie nie powodują awarii całego procesu.
8. Na koniec drukujemy całkowitą liczbę pobranych bajtów i czas wykonania.

Zalety ThreadPoolExecutor

• Uproszczona współbieżność: Zapewnia czysty i łatwy w użyciu interfejs do zarządzania wątkami.
• Wydajność I/O-bound: Doskonały do zadań, które spędzają znaczną ilość czasu na oczekiwaniu na operacje I/O, takie jak żądania sieciowe, odczyt plików lub zapytania do baz danych.
• Niższy narzut: Wątki zazwyczaj mają niższy narzut w porównaniu do procesów, co czyni je bardziej wydajnymi w przypadku zadań obejmujących częste przełączanie kontekstu.

Ograniczenia ThreadPoolExecutor

• Ograniczenie GIL: GIL ogranicza prawdziwą równoległość zadań CPU-bound. Tylko jeden wątek może wykonywać kod bajtowy Pythona naraz, niwelując korzyści z wielu rdzeni.
• Złożoność debugowania: Debugowanie aplikacji wielowątkowych może być trudne ze względu na warunki wyścigu i inne problemy związane ze współbieżnością.

ProcessPoolExecutor: Uwalnianie wieloprocesowości dla zadań CPU-bound

ProcessPoolExecutor przezwycięża ograniczenie GIL, tworząc pulę procesów roboczych. Każdy proces ma własny interpreter Pythona i przestrzeń pamięci, co pozwala na prawdziwą równoległość w systemach wielordzeniowych. Czyni to go idealnym do zadań CPU-bound, które obejmują intensywne obliczenia.

Podstawowe użycie

Rozważmy intensywne obliczeniowo zadanie, takie jak obliczenie sumy kwadratów dla dużego zakresu liczb. Oto jak użyć ProcessPoolExecutor do zrównoleglenia tego zadania:

import concurrent.futures
import time
import os

def sum_of_squares(start, end):
    pid = os.getpid()
    print(f"ID procesu: {pid}, Obliczanie sumy kwadratów od {start} do {end}")
    total = 0
    for i in range(start, end + 1):
        total += i * i
    return total


if __name__ == "__main__": # Ważne, aby uniknąć rekurencyjnego uruchamiania w niektórych środowiskach
    start_time = time.time()
    range_size = 1000000
    num_processes = 4
    ranges = [(i * range_size + 1, (i + 1) * range_size) for i in range(num_processes)]

    with concurrent.futures.ProcessPoolExecutor(max_workers=num_processes) as executor:
        futures = [executor.submit(sum_of_squares, start, end) for start, end in ranges]
        results = [future.result() for future in concurrent.futures.as_completed(futures)]

    total_sum = sum(results)
    print(f"Całkowita suma kwadratów: {total_sum}")
    print(f"Czas wykonania: {time.time() - start_time:.2f} sekund")

Wyjaśnienie:

1. Definiujemy funkcję sum_of_squares, która oblicza sumę kwadratów dla danego zakresu liczb. Dołączamy `os.getpid()`, aby zobaczyć, który proces wykonuje dany zakres.
2. Definiujemy rozmiar zakresu i liczbę procesów do użycia. Lista ranges jest tworzona w celu podzielenia całkowitego zakresu obliczeń na mniejsze części, po jednej dla każdego procesu.
3. Tworzymy ProcessPoolExecutor z określoną liczbą procesów roboczych.
4. Przesyłamy każdy zakres do executor za pomocą executor.submit(sum_of_squares, start, end).
5. Zbieramy wyniki z każdego future za pomocą future.result().
6. Sumujemy wyniki ze wszystkich procesów, aby uzyskać ostateczną całość.

Ważna uwaga: Podczas korzystania z ProcessPoolExecutor, szczególnie w systemie Windows, należy umieścić kod tworzący executor w bloku if __name__ == "__main__":. Zapobiega to rekurencyjnemu tworzeniu procesów, które może prowadzić do błędów i nieoczekiwanego zachowania. Dzieje się tak, ponieważ moduł jest ponownie importowany w każdym procesie potomnym.

Zalety ProcessPoolExecutor

• Prawdziwa równoległość: Obejmuje ograniczenie GIL, umożliwiając prawdziwą równoległość w systemach wielordzeniowych dla zadań CPU-bound.
• Poprawiona wydajność dla zadań CPU-bound: Można osiągnąć znaczną poprawę wydajności dla operacji intensywnie wykorzystujących obliczenia.
• Niezawodność: Jeśli jeden proces ulegnie awarii, niekoniecznie musi to spowodować awarię całego programu, ponieważ procesy są od siebie odizolowane.

Ograniczenia ProcessPoolExecutor

• Wyższy narzut: Tworzenie i zarządzanie procesami wiąże się z wyższym narzutem w porównaniu do wątków.
• Komunikacja międzyprocesowa: Udostępnianie danych między procesami może być bardziej złożone i wymaga mechanizmów komunikacji międzyprocesowej (IPC), które mogą generować narzut.
• Zużycie pamięci: Każdy proces ma własną przestrzeń pamięci, co może zwiększyć ogólne zużycie pamięci przez aplikację. Przekazywanie dużych ilości danych między procesami może stać się wąskim gardłem.

Wybór właściwego executor: ThreadPoolExecutor vs. ProcessPoolExecutor

Klucz do wyboru między ThreadPoolExecutor a ProcessPoolExecutor polega na zrozumieniu natury Twoich zadań:

• Zadania I/O-bound: Jeśli Twoje zadania spędzają większość czasu na oczekiwaniu na operacje I/O (np. żądania sieciowe, odczyt plików, zapytania do baz danych), ThreadPoolExecutor jest zazwyczaj lepszym wyborem. GIL jest mniej wąskim gardłem w tych scenariuszach, a niższy narzut wątków czyni je bardziej wydajnymi.
• Zadania CPU-bound: Jeśli Twoje zadania są intensywnie wykorzystujące obliczenia i wykorzystują wiele rdzeni, ProcessPoolExecutor jest właściwym wyborem. Omija ograniczenie GIL i pozwala na prawdziwą równoległość, co skutkuje znaczną poprawą wydajności.

Oto tabela podsumowująca kluczowe różnice:

Cecha	ThreadPoolExecutor	ProcessPoolExecutor
Model współbieżności	Wielowątkowość	Wieloprocesowość
Wpływ GIL	Ograniczony przez GIL	Omija GIL
Odpowiedni do	Zadań I/O-bound	Zadań CPU-bound
Narzut	Niższy	Wyższy
Zużycie pamięci	Niższe	Wyższe
Komunikacja międzyprocesowa	Nie wymagana (wątki współdzielą pamięć)	Wymagana do udostępniania danych
Niezawodność	Mniej niezawodny (awaria może wpłynąć na cały proces)	Bardziej niezawodny (procesy są odizolowane)

Zaawansowane techniki i uwagi

Przesyłanie zadań z argumentami

Oba executory pozwalają na przekazywanie argumentów do wykonywanej funkcji. Odbywa się to za pomocą metody submit():

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function, arg1, arg2)
    result = future.result()

Obsługa wyjątków

Wyjątki zgłoszone w wykonywanej funkcji nie są automatycznie propagowane do wątku głównego lub procesu. Należy je jawnie obsłużyć podczas pobierania wyniku Future:

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function)
    try:
        result = future.result()
    except Exception as e:
        print(f"Wystąpił wyjątek: {e}")

Używanie `map` do prostych zadań

W przypadku prostych zadań, gdzie chcesz zastosować tę samą funkcję do sekwencji danych wejściowych, metoda map() zapewnia zwięzły sposób przesyłania zadań:

def square(x):
    return x * x


with concurrent.futures.ProcessPoolExecutor() as executor:
    numbers = [1, 2, 3, 4, 5]
    results = executor.map(square, numbers)
    print(list(results))

Kontrolowanie liczby pracowników

Argument max_workers w ThreadPoolExecutor i ProcessPoolExecutor kontroluje maksymalną liczbę wątków lub procesów, które mogą być używane jednocześnie. Wybór odpowiedniej wartości dla max_workers jest ważny dla wydajności. Dobrym punktem wyjścia jest liczba rdzeni procesora dostępnych w Twoim systemie. Jednak w przypadku zadań I/O-bound możesz skorzystać z użycia większej liczby wątków niż rdzeni, ponieważ wątki mogą przełączać się na inne zadania podczas oczekiwania na I/O. Eksperymentowanie i profilowanie są często niezbędne do określenia optymalnej wartości.

Monitorowanie postępów

Moduł concurrent.futures nie zapewnia wbudowanych mechanizmów bezpośredniego monitorowania postępów zadań. Możesz jednak zaimplementować własne śledzenie postępów za pomocą wywołań zwrotnych lub współdzielonych zmiennych. Biblioteki takie jak `tqdm` mogą być zintegrowane w celu wyświetlania pasków postępu.

Przykłady z życia wzięte

Rozważmy kilka scenariuszy z życia, w których ThreadPoolExecutor i ProcessPoolExecutor mogą być skutecznie stosowane:

• Web scraping: Jednoczesne pobieranie i parsowanie wielu stron internetowych przy użyciu ThreadPoolExecutor. Każdy wątek może obsługiwać inną stronę internetową, poprawiając ogólną szybkość scrapingu. Należy pamiętać o warunkach korzystania z usług stron internetowych i unikać przeciążania ich serwerów.
• Przetwarzanie obrazów: Stosowanie filtrów lub transformacji obrazów do dużej grupy obrazów przy użyciu ProcessPoolExecutor. Każdy proces może obsługiwać inny obraz, wykorzystując wiele rdzeni do szybszego przetwarzania. Rozważ biblioteki takie jak OpenCV do wydajnej manipulacji obrazami.
• Analiza danych: Wykonywanie złożonych obliczeń na dużych zbiorach danych przy użyciu ProcessPoolExecutor. Każdy proces może analizować podzbiór danych, zmniejszając ogólny czas analizy. Pandas i NumPy to popularne biblioteki do analizy danych w Pythonie.
• Uczenie maszynowe: Trenowanie modeli uczenia maszynowego przy użyciu ProcessPoolExecutor. Niektóre algorytmy uczenia maszynowego można skutecznie zrównoleglić, co pozwala na szybsze trenowanie. Biblioteki takie jak scikit-learn i TensorFlow oferują wsparcie dla równoległości.
• Kodowanie wideo: Konwertowanie plików wideo do różnych formatów przy użyciu ProcessPoolExecutor. Każdy proces może kodować inny segment wideo, co przyspiesza cały proces kodowania.

Uwagi globalne

Podczas tworzenia aplikacji współbieżnych dla globalnej publiczności, ważne jest, aby wziąć pod uwagę następujące kwestie:

• Strefy czasowe: Należy zwracać uwagę na strefy czasowe podczas pracy z operacjami wrażliwymi na czas. Używaj bibliotek takich jak pytz do konwersji stref czasowych.
• Ustawienia regionalne: Upewnij się, że Twoja aplikacja poprawnie obsługuje różne ustawienia regionalne. Użyj bibliotek takich jak locale do formatowania liczb, dat i walut zgodnie z ustawieniami regionalnymi użytkownika.
• Kodowania znaków: Używaj Unicode (UTF-8) jako domyślnego kodowania znaków, aby obsługiwać szeroki zakres języków.
• Internacjonalizacja (i18n) i lokalizacja (l10n): Zaprojektuj swoją aplikację tak, aby można ją było łatwo internacjonalizować i lokalizować. Użyj gettext lub innych bibliotek tłumaczeniowych, aby zapewnić tłumaczenia na różne języki.
• Opóźnienia sieciowe: Weź pod uwagę opóźnienia sieciowe podczas komunikacji z odległymi usługami. Zaimplementuj odpowiednie limity czasowe i obsługę błędów, aby zapewnić, że Twoja aplikacja jest odporna na problemy sieciowe. Lokalizacja geograficzna serwerów może znacznie wpłynąć na opóźnienia. Rozważ użycie sieci dostarczania treści (CDN), aby poprawić wydajność dla użytkowników w różnych regionach.

Wnioski

Moduł concurrent.futures zapewnia potężny i wygodny sposób wprowadzania współbieżności i równoległości do Twoich aplikacji w Pythonie. Rozumiejąc różnice między ThreadPoolExecutor a ProcessPoolExecutor, a także starannie rozważając naturę Twoich zadań, możesz znacząco poprawić wydajność i responsywność swojego kodu. Pamiętaj, aby profilować swój kod i eksperymentować z różnymi konfiguracjami, aby znaleźć optymalne ustawienia dla Twojego konkretnego przypadku użycia. Bądź również świadomy ograniczeń GIL i potencjalnych złożoności programowania wielowątkowego i wieloprocesowego. Dzięki starannemu planowaniu i wdrożeniu możesz odblokować pełny potencjał współbieżności w Pythonie i tworzyć niezawodne, skalowalne aplikacje dla globalnej publiczności.